With advances in processing capabilities and programming technologies, software defined mobile wireless communications devices (e.g., radios) continue to increase in popularity. Rather than relying upon hardware and circuitry components to perform tasks such as frequency, modulation, bandwidth, security functions, and waveform requirements, these functions are performed by software modules or components in a software defined radio. In a software defined radio (SDR), analog signals are converted into the digital domain where the above-noted functions may be performed using digital signal processing.
Because most of the functions of the radio are controlled by software, these radios may typically be implemented with relatively standard processor and hardware components. This may not only reduce device hardware costs, but also provide greater flexibility in upgrading the device since new communications waveform modules can be uploaded to the device relatively easily and without the need to interchange new hardware components.
One particular class of software defined radio, which takes advantage of the above-described advantages and features, is the Joint Tactical Radio (JTR). The JTR radio includes relatively standard radio and processing hardware along with the appropriate waveform software modules for the communication waveforms the radio will use. JTR's also use operating system software that conforms with the Software Communications Architecture (SCA) Specification (see www.JTRS.saalt.mil), which is hereby incorporated by reference in its entirety. The SCA is an open architecture framework that specifies how hardware and software components interoperate such that different manufacturers and developers can readily integrate their respective components into a single device.
Still another class of mobile wireless communications devices that increasingly use software components for communicating with different waveforms or protocols are cellular communication devices. That is, many cellular devices are now designed to operate with more than one of the numerous cellular standards that are used throughout the world, such as the Global System for Mobile Communications (GSM) and Personal Communications Services (PCS), for example.
The Joint Tactical Radio System (JTRS) Software Communications Architecture (SCA) defines a set of interfaces and protocols, often based on the Common Object Request Broker Architecture (CORBA), for implementing a software defined radio. In part, JTRS and its SCA are used with a family of software reprogrammable radios. As such, the SCA is a specific set of rules, methods, and design criteria for implementing software re-programmable digital radios.
The JTRS SCA specification is published by the JTRS Joint Program Office (JPO). The JTRS SCA has been structured to provide for portability of applications software between different JTRS SCA implementations, leverage commercial standards to reduce development cost, reduce development time of new waveforms through the ability to reuse design modules, and build on evolving commercial frameworks and architectures.
The JTRS SCA is not a system specification, as it is intended to be implementation independent, but a set of rules that constrain the design of systems to achieve desired JTRS objectives. The software framework of the JTRS SCA defines the Operating Environment (OE) and specifies the services and interfaces that applications use from that environment. The SCA OE comprises a Core Framework (CF), a CORBA middleware, and an Operating System (OS) based on the Portable Operating System Interface (POSIX) with associated board support packages. The JTRS SCA also provides a building block structure (defined in the API Supplement) for defining application programming interfaces (APIs) between application software components.
The JTRS SCA Core Framework (CF) is an architectural concept defining the essential, “core” set of open software Interfaces and Profiles that provide for the deployment, management, interconnection, and intercommunication of software application components in embedded, distributed-computing communication systems. Interfaces may be defined in the JTRS SCA Specification. However, developers may implement some of them; some may be implemented by non-core applications (i.e., waveforms, etc.); and some may be implemented by hardware device providers. The specifications for the JTRS radio and SCA typically require an interface for command and data (red and black) processing systems. A radio platform may include multiprocessor embedded systems, including Field Programmable Gate Arrays (FPGA's).
In this type of framework, instead of using a custom build for individual radios, the system uses XML files associated with waveform components and hardware devices that allow waveform start-up to be defined while allocating components. When objects are instantiated, they can be distributed among different processing elements of the radio with a set of XML files associated with each software and hardware object.
The SCA framework provides a mechanism for loading a driver or executable when the waveform is instantiated. There are still requirements to dynamically reload DSP components at run-time from a list of platform and waveform-specific components. A common DSP core is still needed that can request components and an extension of the SCA framework to provide the components to the DSP. In current systems, a DSP image is loaded as a static binary image when the radio is initialized or a waveform is instantiated as specified by the waveform XML. After the waveform is instantiated, there is no further loading. This is not always desirable.